import * as fs from 'fs';
import * as path from 'path';
import { Logger } from '../../../src/logger/Logger';

/**
 * UT Prompt 增强器
 * 
 * 功能：将深度学习的知识注入到 LLM Prompt 中
 * - 真实的测试示例（test.cpp 内函数写法）
 * - HWTEST_F 框架使用示例
 * - Mock 使用、断言模式
 * - 完整的 BUILD.gn 示例（ohos_unittest、group）
 */
export class UTPromptEnhancer {
    private static comprehensiveKnowledge: any = null;
    private static gnPatterns: any = null;
    
    /**
     * 初始化知识库
     */
    public static initialize(extensionPath: string): void {
        const comprehensivePath = path.join(extensionPath, 'core', 'knowledge', 'comprehensive-all-projects.json');
        const gnPatternsPath = path.join(extensionPath, 'core', 'knowledge', 'gn-patterns.json');
        
        // 加载综合知识库
        if (fs.existsSync(comprehensivePath)) {
            try {
                const content = fs.readFileSync(comprehensivePath, 'utf-8');
                this.comprehensiveKnowledge = JSON.parse(content);
                Logger.info(`[UTPromptEnhancer] ✅ 加载综合知识库`);
            } catch (err: any) {
                Logger.error(`[UTPromptEnhancer] ❌ 加载综合知识库失败: ${err.message}`);
            }
        }
        
        // 加载 GN 模式
        if (fs.existsSync(gnPatternsPath)) {
            try {
                const content = fs.readFileSync(gnPatternsPath, 'utf-8');
                this.gnPatterns = JSON.parse(content);
                Logger.info(`[UTPromptEnhancer] ✅ 加载 GN 模式`);
            } catch (err: any) {
                Logger.error(`[UTPromptEnhancer] ❌ 加载 GN 模式失败: ${err.message}`);
            }
        }
    }
    
    /**
     * 获取 HWTEST_F 真实示例（test.cpp 内函数写法）
     */
    public static getHWTESTFExamples(): string {
        if (!this.comprehensiveKnowledge?.testPatterns?.hwtestExamples) {
            return '';
        }
        
        const examples = this.comprehensiveKnowledge.testPatterns.hwtestExamples.slice(0, 3);
        
        if (examples.length === 0) {
            return '';
        }
        
        return `
**📚 真实项目中的 HWTEST_F 示例（学习如何编写 test.cpp）：**

${examples.map((ex: any, idx: number) => `
**示例 ${idx + 1}：** ${ex.testName}
\`\`\`cpp
HWTEST_F(${ex.className}, ${ex.testName}, ${ex.level})
{
${ex.body}
}
\`\`\`
`).join('\n')}

**关键要点：**
- ✅ 所有示例都来自 OpenHarmony 23 个真实项目
- ✅ 学习它们的测试场景设计、断言方式
- ✅ 模仿它们的代码风格和边界值测试
`;
    }
    
    /**
     * 获取 Mock 使用示例
     */
    public static getMockExamples(): string {
        if (!this.comprehensiveKnowledge?.testPatterns?.mockExamples) {
            return '';
        }
        
        const examples = this.comprehensiveKnowledge.testPatterns.mockExamples.slice(0, 5);
        
        if (examples.length === 0) {
            return '';
        }
        
        return `
**🎭 Mock 使用示例（来自真实项目）：**

${examples.map((ex: string) => `\`\`\`cpp\n${ex}\n\`\`\``).join('\n\n')}

**Mock 要点：**
- 使用 gmock 框架（EXPECT_CALL、ON_CALL）
- 适用于测试依赖外部接口的函数
`;
    }
    
    /**
     * 获取断言模式
     */
    public static getAssertionPatterns(): string {
        if (!this.comprehensiveKnowledge?.testPatterns?.assertionExamples) {
            return '';
        }
        
        const examples = this.comprehensiveKnowledge.testPatterns.assertionExamples.slice(0, 10);
        
        if (examples.length === 0) {
            return '';
        }
        
        return `
**✅ 断言模式（EXPECT_* 使用方法）：**

${examples.map((ex: string) => `- \`${ex}\``).join('\n')}

**常用断言：**
- EXPECT_EQ / EXPECT_NE：相等/不相等
- EXPECT_TRUE / EXPECT_FALSE：布尔值
- EXPECT_GT / EXPECT_LT：大于/小于
- EXPECT_STREQ / EXPECT_STRNE：字符串相等/不相等
`;
    }
    
    /**
     * 获取 SetUp/TearDown 示例
     */
    public static getSetUpTearDownExamples(): string {
        if (!this.comprehensiveKnowledge?.testPatterns?.setupTeardownExamples) {
            return '';
        }
        
        const examples = this.comprehensiveKnowledge.testPatterns.setupTeardownExamples.slice(0, 2);
        
        if (examples.length === 0) {
            return '';
        }
        
        return `
**🔧 SetUp/TearDown 使用示例：**

${examples.map((ex: string, idx: number) => `
**示例 ${idx + 1}：**
\`\`\`cpp
${ex}
\`\`\`
`).join('\n')}

**使用场景：**
- SetUp()：在每个测试用例前执行（初始化资源）
- TearDown()：在每个测试用例后执行（清理资源）
`;
    }
    
    /**
     * 获取完整的 ohos_unittest BUILD.gn 示例
     */
    public static getCompleteUnittestBuildGnExample(): string {
        if (!this.gnPatterns?.unittestTargets || this.gnPatterns.unittestTargets.length === 0) {
            return '';
        }
        
        const example = this.gnPatterns.unittestTargets[0];
        
        return `
**🔧 真实的 ohos_unittest BUILD.gn 示例（来自 OpenHarmony 项目）：**

\`\`\`gn
${example.fullExample}
\`\`\`

**关键字段：**
- \`module_out_path\`: "${example.moduleOutPath || '必须填写'}"
- \`sources\`: ${example.sources} 个测试文件
- \`deps\`: ${example.deps} 个依赖
- \`external_deps\`: ${example.externalDeps} 个外部依赖

**❌ 严禁省略：**
- ❌ 不要省略 deps 和 external_deps（即使很多也要全部列出）
- ❌ 不要使用 "... 其余XX项省略" 这样的标记
`;
    }
    
    /**
     * 获取常用头文件
     */
    public static getCommonTestHeaders(): string {
        if (!this.comprehensiveKnowledge?.commonHeaders) {
            return '';
        }
        
        const testHeaders = this.comprehensiveKnowledge.commonHeaders
            .filter((h: any) => h.header.includes('gtest') || h.header.includes('gmock') || 
                                h.header === 'securec.h' || h.header === 'string' || 
                                h.header === 'memory' || h.header === 'vector')
            .slice(0, 10);
        
        if (testHeaders.length === 0) {
            return '';
        }
        
        return `
**📄 测试中最常用的头文件：**

${testHeaders.map((h: any, idx: number) => `${idx + 1}. \`#include <${h.header}>\` (使用 ${h.count} 次)`).join('\n')}
`;
    }
    
    /**
     * 构建完整的增强 Prompt
     */
    public static buildEnhancedPrompt(basePrompt: string): string {
        const enhancements = [
            this.getHWTESTFExamples(),
            this.getAssertionPatterns(),
            this.getMockExamples(),
            this.getSetUpTearDownExamples(),
            this.getCommonTestHeaders(),
            this.getCompleteUnittestBuildGnExample()
        ].filter(e => e.length > 0);
        
        if (enhancements.length === 0) {
            Logger.warn(`[UTPromptEnhancer] ⚠️  没有加载到知识库，使用基础 Prompt`);
            return basePrompt;
        }
        
        Logger.info(`[UTPromptEnhancer] ✅ 使用 ${enhancements.length} 项增强内容`);
        
        return `${basePrompt}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

## 🎓 深度学习知识库（来自 23 个 OpenHarmony 真实项目）

以下内容是从 23 个 OpenHarmony 项目中分析了 **34,156 个文件** 后提取的：
- ✅ 8,808 个源文件 (.cpp)
- ✅ 4,747 个测试文件
- ✅ 4,740 个 BUILD.gn 文件

**请严格参考这些真实示例生成代码，确保：**
- ✅ 测试覆盖率 >80%
- ✅ 编译通过率 >90%
- ✅ 测试用例质量高（包含边界值、异常情况）

${enhancements.join('\n\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n')}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

**🎯 最终要求：**
1. ✅ 代码风格必须与上述真实示例保持一致
2. ✅ 每个函数至少3个测试用例（正常、边界、异常）
3. ✅ 所有头文件、依赖必须真实存在
4. ✅ BUILD.gn 配置必须完整
5. ✅ 确保生成的代码可以直接编译通过
`;
    }
}

